package Bricks;

public class Core {

    /*这里的坐标系，是这样规定的，一个矩形，其左上角坐标（0，0），右下角坐标（23，9），在这里面，我习惯先写y（纵坐标值），再写x（横坐标值）
    *既是习惯，也是这里面的准则
    *这里的一维数组将用来存放，移动中的方块的横纵坐标值
    * 它们两两一对，其中，前面的那一个代表纵坐标（偶数索引），后面那一个代表横坐标（奇数索引）
    * 同时，我规定，往这个数组里存放方块坐标时，依照从上到下，从左到右的原则，
    * 例如：正方形方块，放在数组里应该是这样的：左上角、右上角、左下角、右下角
    * 方块坐标添加完成后，我再在其尾部添加一个特殊的数字，用这个数字来标识方块的形状，以便处理它的变换
    * 尾部为0：正方形、 尾部为1：竖直长条、 尾部为2：横向长条、 尾部为3：Z型、 尾部为4：Z形竖直、 尾部为5：反向Z形、 尾部为6：反向Z形竖直
    * 尾部为7： 凸形、 尾部为8：右向凸形、 尾部为9：下向凸形、 尾部为10：左向凸形、 尾部11：L形、 尾部12：下向L形、 尾部13：左向L形、 尾部14：上向L形、
    * 尾部15：翻转L形、 尾部16：上向翻转L形、 尾部17：右向翻转L形、 尾部18：下向翻转L形、*/
    public static int[][] twoArray;  //核心二维数组
    public static int[] movingArray = new int[9];  //移动中的方块的坐标集合
    public static int[] movingArrayAnticipation = new int[9];  //移动中的方块落点预判坐标集合
    public static int score;  //得分情况
    public static int threadDeath;  //掌管搬运与打印线程的生死，0为死，1为生
    public static int modelofNmber;  //游戏模式序号，不同的序号对应一些不同的操作


    public Core(){
        /*24行，10列，其中首四行，用来作为方块的出生区域，
        * 余下的20行，10列，就为方块活动区域*/
        ///初始化核心数组，并用数字0填充满
        twoArray = new int[24][10];
        /// 填充核心数组，初始值都为0，
        /// 值为0时，代表没有方块；值为1时，代表有方块（移动中的方块，理解为尝试往数组中填充‘1’）
        for(int i = 0; i < 24; i ++){
            int [] row = new int[10];
            for(int j = 0; j < 10; j ++){
                row[j] = 0;
            }
            twoArray[i] = row;
        }
        threadDeath = 1;  //搬运和打印两个线程可以运行
        score = 0;  //分数重置
        modelofNmber = 1; //缺省启动休闲模式

        ///第一个方块生成
        createNewCube(randomNumber(0,18));

    }
    //获取当前移动中的方块的最大横坐标
    public static int maxAbscissa(){
        int maxAbscissaNumber = 0;
        for(int i = 0; i < movingArray.length -1; i ++ ){
            if(i % 2 == 0) continue;
            if(movingArray[i] > maxAbscissaNumber) maxAbscissaNumber = movingArray[i];
        }
        return maxAbscissaNumber;
    }
    //获取当前移动方块的最小横坐标
    public static int minAbscissa(){
        int minAbscissaNumber = 9;
        for(int i = 0; i < movingArray.length -1; i ++ ){
            if(i % 2 == 0) continue;
            if(movingArray[i] < minAbscissaNumber) minAbscissaNumber = movingArray[i];
        }
        return minAbscissaNumber;
    }
    //判断当前移动方块是否能够右移
    public static boolean canShiftRight(){
        boolean shiftRight = true;  //缺省能右移
        for(int i = movingArray.length - 2; i > 0; i -- ){
            if(i % 2 == 0) continue;  //纵坐标跳过
            if(movingArray[i] == 9 || twoArray[movingArray[i - 1]][movingArray[i] +1] == 1) {
                shiftRight = false;
                break;
            }
        }
        return shiftRight;
    }
    //判断当前移动方块是否能够左移
    public static boolean canShiftLeft(){
        boolean shiftLeft = true;  //缺省能左移
        for(int i = movingArray.length - 2; i > 0; i -- ){
            if(i % 2 == 0) continue;  //纵坐标跳过
            //一定要理解的话,就是到达了左边边界,或者左边有已经填充好的方块,就不能左移了
            if(movingArray[i] == 0 || twoArray[movingArray[i - 1]][movingArray[i] - 1] == 1) {
                shiftLeft = false;
                break;
            }
        }
        return shiftLeft;
    }
    //变形
    public static void deformation(){
        switch (Core.movingArray[Core.movingArray.length - 1]){
            case 1:  //竖直长条变形
                Core.movingArray = deformationVerticalStrip(Core.movingArray);
                break;
            case 2:  //横向长条变形
                Core.movingArray = deformationHorizontalStrip(Core.movingArray);
                break;
            case 3:  //Z形变形
                Core.movingArray = deformationZ(Core.movingArray);
                break;
            case 4:  //Z形竖直态变形
                Core.movingArray = deformationZ_Upright(Core.movingArray);
                break;
            case 5:  //反向Z形变形
                Core.movingArray = deformationReverseZ(Core.movingArray);
                break;
            case 6:  //反向Z形竖直态变形
                Core.movingArray = deformationReverseZ_Upright(Core.movingArray);
                break;
            case 7:  //凸形变形
                Core.movingArray = deformationConvex(Core.movingArray);
                break;
            case 8:  //凸形右态变形
                Core.movingArray = deformationConvex_Right(Core.movingArray);
                break;
            case 9:  //凸形下态变形
                Core.movingArray = deformationConvex_Down(Core.movingArray);
                break;
            case 10:  //凸形左态变形
                Core.movingArray = deformationConvex_Left(Core.movingArray);
                break;
            case 11:  //L形变形
                Core.movingArray = deformationL(Core.movingArray);
                break;
            case 12:  //L形下态变形
                Core.movingArray = deformationL_Down(Core.movingArray);
                break;
            case 13:  //L形左态变形
                Core.movingArray = deformationL_Left(Core.movingArray);
                break;
            case 14:  //L形上态变形
                Core.movingArray = deformationL_Upper(Core.movingArray);
                break;
            case 15:  //翻转L形变形
                Core.movingArray = deformationFlipL(Core.movingArray);
                break;
            case 16:  //翻转L形上态变形
                Core.movingArray = deformationFlipL_Upper(Core.movingArray);
                break;
            case 17:  //翻转L形右态变形
                Core.movingArray = deformationFlipL_Right(Core.movingArray);
                break;
            case 18:  //翻转L形下态变形
                Core.movingArray = deformationFlipL_Down(Core.movingArray);
                break;
        }
    }
    /*以下过程中所提到的围绕某个点进行旋转，其实这种说法也不算准确，
    因为它们的四个点，无论你选择哪个点作为旋转点，它们都是不对称的图形
    * */
    //竖直长条变换,返回变换后的坐标值
    //竖直长条的变换，主要围绕它的第三个点进行旋转
    public static int[] deformationVerticalStrip(int[] coordinateArray){
        int [] resultArray = coordinateArray;
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int coreAbscissa = coordinateArray[5];  //核心点横坐标
        int coreOrdinate = coordinateArray[4];  //核心点纵坐标
        int minus = 2;  //嗯，一个有用，但是不好描述的数
        for(int i = 0; i < coordinateArray.length - 1 ; i ++){
            if(i%2 == 0) afterDeformationedArray[i] = coreOrdinate;
            else {
                afterDeformationedArray[i] = coreAbscissa - minus;
                minus --;
            }
        }
        afterDeformationedArray[8] = 2;  //改变方块标识为横向长条,注意索引值溢出。。。。一个不小心，调了半个多小时
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //横向长条变换,返回变换后的坐标值
    //横向长条的变换，主要围绕它的第三个点进行旋转
    public static int[] deformationHorizontalStrip(int[] coordinateArray){
        int [] resultArray = coordinateArray;
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int coreAbscissa = coordinateArray[5];  //核心点横坐标
        int coreOrdinate = coordinateArray[4];  //核心点纵坐标
        int minus = 2;  //嗯，一个有用，但是不好描述的数
        for(int i = 0; i < coordinateArray.length - 1 ; i ++){
            if(i%2 == 0) {
                afterDeformationedArray[i] = coreOrdinate - minus;
                minus --;
            }
            else {
                afterDeformationedArray[i] = coreAbscissa;
            }
        }
        afterDeformationedArray[8] = 1;  //改变方块标识为竖直长条,注意索引值溢出。。。。一个不小心，调了半个多小时
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //Z形方块的变换,返回变换后的坐标值
    //Z形方块的变换，主要围绕它的第三个点进行旋转
    //且注意，我们即使要按照核心方块点进行旋转，旋转之后的存放坐标的顺序，也应和我们最开始定义的保持一致
    //即从上到下，从左到右依次放入小块
    public static int[] deformationZ(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[4];  //核心点纵坐标
        int abscissaCore = coordinateArray[5];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore + 1;

        afterDeformationedArray[2] = ordinateCore + 0;
        afterDeformationedArray[3] = abscissaCore + 0;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 1;

        afterDeformationedArray[6] = ordinateCore + 1;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 4;  //改变方块标识为竖直Z形
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //Z形竖直方块的变换,返回变换后的坐标值
    //Z形竖直方块的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationZ_Upright(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore - 1;

        afterDeformationedArray[2] = ordinateCore - 1;
        afterDeformationedArray[3] = abscissaCore + 0;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 0;

        afterDeformationedArray[6] = ordinateCore + 0;
        afterDeformationedArray[7] = abscissaCore + 1;


        afterDeformationedArray[8] = 3;  //改变方块标识为Z形
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //反向Z形方块的变换,返回变换后的坐标值
    //反向Z形方块的变换，主要围绕它的第四个点进行旋转
    public static int[] deformationReverseZ(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[6];  //核心点纵坐标
        int abscissaCore = coordinateArray[7];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore - 1;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore - 1;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 0;

        afterDeformationedArray[6] = ordinateCore + 1;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 6;  //改变方块标识为反向Z形竖直
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //反向Z形竖直方块的变换,返回变换后的坐标值
    //反向Z形竖直方块的变换，主要围绕它的第三个点进行旋转
    public static int[] deformationReverseZ_Upright(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[4];  //核心点纵坐标
        int abscissaCore = coordinateArray[5];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore - 0;

        afterDeformationedArray[2] = ordinateCore - 1;
        afterDeformationedArray[3] = abscissaCore + 1;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore - 1;

        afterDeformationedArray[6] = ordinateCore + 0;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 5;  //改变方块标识为反向Z形
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //凸形方块的变换,返回变换后的坐标值
    //凸形方块的变换，主要围绕它的第三个点进行旋转
    public static int[] deformationConvex(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[4];  //核心点纵坐标
        int abscissaCore = coordinateArray[5];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore - 0;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore + 0;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 1;

        afterDeformationedArray[6] = ordinateCore + 1;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 8;  //改变方块标识为凸形右向
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //凸形右向方块的变换,返回变换后的坐标值
    //凸形右向方块的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationConvex_Right(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 0;
        afterDeformationedArray[1] = abscissaCore - 1;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore + 0;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 1;

        afterDeformationedArray[6] = ordinateCore + 1;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 9;  //改变方块标识为凸形下向
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //凸形下向方块的变换,返回变换后的坐标值
    //凸形下向方块的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationConvex_Down(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore - 0;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore - 1;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 0;

        afterDeformationedArray[6] = ordinateCore + 1;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 10;  //改变方块标识为凸形左向
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //凸形左向方块的变换,返回变换后的坐标值
    //凸形左向方块的变换，主要围绕它的第三个点进行旋转
    public static int[] deformationConvex_Left(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[4];  //核心点纵坐标
        int abscissaCore = coordinateArray[5];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore - 0;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore - 1;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 0;

        afterDeformationedArray[6] = ordinateCore + 0;
        afterDeformationedArray[7] = abscissaCore + 1;


        afterDeformationedArray[8] = 7;  //改变方块标识为凸形
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    /*L的变形似乎有些特殊，又或者我想到的方法不够本质，所以不适用所有
    * 它一共有四种形态，但是，之前的凸形，哪怕变换也是四次，它始终会有一个点的坐标，在四次变换中不会变动
    * 但是到了L这里，。。。。。。不存在一个点，在四次变换中都保持不变
    * 虽然它有这样的不同，但是还是可以写，看看效果吧*/
    //L形方块的变换,返回变换后的坐标值
    //L形方块的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationL(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore - 0;

        afterDeformationedArray[2] = ordinateCore - 1;
        afterDeformationedArray[3] = abscissaCore + 1;

        afterDeformationedArray[4] = ordinateCore - 1;
        afterDeformationedArray[5] = abscissaCore + 2;

        afterDeformationedArray[6] = ordinateCore + 0;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 12;  //改变方块标识为L形下态
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //L形下态的变换,返回变换后的坐标值
    //L形下态的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationL_Down(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 0;
        afterDeformationedArray[1] = abscissaCore - 1;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore + 0;

        afterDeformationedArray[4] = ordinateCore + 1;
        afterDeformationedArray[5] = abscissaCore + 0;

        afterDeformationedArray[6] = ordinateCore + 2;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 13;  //改变方块标识为L形左态
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //L形左态的变换,返回变换后的坐标值
    //L形左态的变换，主要围绕它的第三个点进行旋转
    public static int[] deformationL_Left(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[4];  //核心点纵坐标
        int abscissaCore = coordinateArray[5];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore + 1;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore - 1;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 0;

        afterDeformationedArray[6] = ordinateCore + 0;
        afterDeformationedArray[7] = abscissaCore + 1;


        afterDeformationedArray[8] = 14;  //改变方块标识为L形上态
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //L形上态的变换,返回变换后的坐标值
    //L形上态的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationL_Upper(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore + 0;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore - 0;

        afterDeformationedArray[4] = ordinateCore + 1;
        afterDeformationedArray[5] = abscissaCore + 0;

        afterDeformationedArray[6] = ordinateCore + 1;
        afterDeformationedArray[7] = abscissaCore + 1;


        afterDeformationedArray[8] = 11;  //改变方块标识为L形
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //翻转L形的变换,返回变换后的坐标值
    //翻转L形的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationFlipL(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore - 1;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore - 1;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 0;

        afterDeformationedArray[6] = ordinateCore + 0;
        afterDeformationedArray[7] = abscissaCore + 1;


        afterDeformationedArray[8] = 16;  //改变方块标识为翻转L形上态
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //翻转L形上态的变换,返回变换后的坐标值
    //翻转L形上态的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationFlipL_Upper(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 1;
        afterDeformationedArray[1] = abscissaCore - 0;

        afterDeformationedArray[2] = ordinateCore - 1;
        afterDeformationedArray[3] = abscissaCore + 1;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 0;

        afterDeformationedArray[6] = ordinateCore + 1;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 17;  //改变方块标识为翻转L形右态
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //翻转L形右态的变换,返回变换后的坐标值
    //翻转L形右态的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationFlipL_Right(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 0;
        afterDeformationedArray[1] = abscissaCore - 1;

        afterDeformationedArray[2] = ordinateCore - 0;
        afterDeformationedArray[3] = abscissaCore + 0;

        afterDeformationedArray[4] = ordinateCore + 0;
        afterDeformationedArray[5] = abscissaCore + 1;

        afterDeformationedArray[6] = ordinateCore + 1;
        afterDeformationedArray[7] = abscissaCore + 1;


        afterDeformationedArray[8] = 18;  //改变方块标识为翻转L形下态
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }
    //翻转L形下态的变换,返回变换后的坐标值
    //翻转L形下态的变换，主要围绕它的第二个点进行旋转
    public static int[] deformationFlipL_Down(int[] coordinateArray){
        int [] resultArray = coordinateArray;  //最终返回的数组
        int [] afterDeformationedArray = new int[9];  //用来存放变换后的坐标数组
        int ordinateCore = coordinateArray[2];  //核心点纵坐标
        int abscissaCore = coordinateArray[3];  //核心点横坐标
        //手写旋转
        afterDeformationedArray[0] = ordinateCore - 0;
        afterDeformationedArray[1] = abscissaCore - 0;

        afterDeformationedArray[2] = ordinateCore + 1;
        afterDeformationedArray[3] = abscissaCore + 0;

        afterDeformationedArray[4] = ordinateCore + 2;
        afterDeformationedArray[5] = abscissaCore - 1;

        afterDeformationedArray[6] = ordinateCore + 2;
        afterDeformationedArray[7] = abscissaCore + 0;


        afterDeformationedArray[8] = 15;  //改变方块标识为翻转L形
        //判断坐标合法性同时，在一定范围内尝试修正，使得我们得到合法坐标（要在允许的范围内）
        if(coordinateIsLegal(afterDeformationedArray)) resultArray = afterDeformationedArray;
        return  resultArray;
    }


    /*判读坐标是否合法
    * 不合法的情况包括：坐标超出边界、坐标代表的位置已经被填充了
    * 然后为了解决一些特殊情况，我们设置一种规则
    * 规则如下：一个竖直长条，来到坐标系最右边，然后，变形，这个时候，按照我们的上面的变换规则，它的最右侧点超出了界限，为不合理的坐标
    * 这时候我们可以尝试，整体左移、或者整体右移、或者整体上移一次，如果在上述任意一个操作中，坐标变得合法了，那这时候我们把坐标更新为
    * 新的合法坐标，然后认定这个新坐标为合法坐标
    * 哦，对了java里这个是引用传值，省了我把更新后坐标传回去的步骤了，才怪
    * 好吧，不是特别理解这个引用传值，最后合法坐标数据得以返回，是对参数coordinateArraySource使用了System.arrayCopy*/
    public static boolean coordinateIsLegal(int [] coordinateArraySource){
        boolean isLegal = true;  //缺省认为坐标是合法的
        int [] coordinateArray = arrayCopy(coordinateArraySource);  //copy一个副本去进行操作，保证源数据的精准
        ///三次机会，左移一次，右移一次，上移一次（先不确定几次机会）
        ///修正四次，应该设置遍历5次
        for(int j = 0 ; j < 5; j ++){
            isLegal = true;  //假想每一次都是一次成功的机会
            for(int i = 0; i < coordinateArray.length-2; i ++){
                if(i%2!=0)continue;
                if(coordinateArray[i] > 23 || coordinateArray[i+1] > 9 || coordinateArray[i + 1] < 0
                        || Core.twoArray[coordinateArray[i]][coordinateArray[i + 1]] == 1){
                    isLegal = false;
                    //坐标不合法，新的副本产生
                    coordinateArray = arrayCopy(coordinateArraySource);
                    break;
                }
            }
            if(isLegal == true){
                System.arraycopy(coordinateArray,0,coordinateArraySource,0,coordinateArraySource.length);//将合法坐标赋予给源坐标，使得源坐标合法
                break; //坐标合法，直接跳出
            }
            else {
                ///第一次不合格，横坐标整体左移，然后再次尝试
                if(j == 0){
                    for(int k = 0; k < coordinateArray.length - 1; k ++){
                        if(k%2 == 0) continue;
                        coordinateArray[k]--;
                    }
                }
                ///第二次不合格，横坐标整体右移，然后再次尝试
                else if(j == 1){
                    for(int k = 0; k < coordinateArray.length - 1; k ++){
                        if(k%2 == 0) continue;
                        coordinateArray[k]++;
                    }
                }
                ///第三次不合格，纵坐标整体上移
                else if (j == 2){
                    for(int k = 0; k < coordinateArray.length - 1; k ++){
                        if(k%2 != 0) continue;
                        coordinateArray[k]--;
                    }
                }
                ///第四次不合格，横坐标整体右移2
                else if (j == 3){
                    for(int k = 0; k < coordinateArray.length - 1; k ++){
                        if(k%2 == 0) continue;
                        coordinateArray[k] += 2;
                    }
                }
            }
        }

        return  isLegal;
    }
    /*方块的急速下降，理想高效的办法，应该是，当你按下指定的下移键，那么这个移动中的方块，就直接跳跃到当前的底部
    * 那么，这个跳跃后的坐标数据，就显得尤为重要了，那怎么得出这个跳跃后的坐标呢？
    * 哦，应该这样，在方法里模拟当前方块的快速下落*/
    public static void fastFall(){
        int temporaryArray [] = arrayCopy(movingArray);  //临时存放
        //至多模拟21次
        for(int i = 0; i < 21; i ++){
            //先弄出模拟值
            for(int j = 0; j < temporaryArray.length-1;j ++){
                if(j%2 != 0 )continue;
                temporaryArray[j]++;
            }
            //检查模拟值的合理
            for(int k = 0; k < temporaryArray.length - 2; k ++){
                if(k%2 !=0)continue;
                if(temporaryArray[k] == 24 || twoArray[temporaryArray[k]][temporaryArray[k+1]] == 1){
                    //此时，坐标数据已为不合法数据，但是，现在只要往后退一纵坐标，即为最佳下落坐标
                    for(int f = 0; f < temporaryArray.length-1;f ++){
                        if(f%2 != 0 )continue;
                        temporaryArray[f]--;
                    }
                    System.arraycopy(temporaryArray,0,movingArray,0,movingArray.length);
                    return;  //目标完成，退出
                }
            }
        }

    }
    //新方块的出生
    public static void createNewCube(int cubeCode){
        int [] itemArray = new int[9];
        switch(cubeCode){
            case 0:  //正方形
                itemArray[0] = 2;
                itemArray[1] = 3;
                itemArray[2] = 2;
                itemArray[3] = 4;
                itemArray[4] = 3;
                itemArray[5] = 3;
                itemArray[6] = 3;
                itemArray[7] = 4;
                itemArray[8] = 0; //0标识方块为正方形
                break;
            case 1:
                itemArray[0] = 0;
                itemArray[1] = 4;
                itemArray[2] = 1;
                itemArray[3] = 4;
                itemArray[4] = 2;
                itemArray[5] = 4;
                itemArray[6] = 3;
                itemArray[7] = 4;
                itemArray[8] = 1; //1标识方块为竖直长条
                break;
            case 2:
                itemArray[0] = 3;
                itemArray[1] = 3;
                itemArray[2] = 3;
                itemArray[3] = 4;
                itemArray[4] = 3;
                itemArray[5] = 5;
                itemArray[6] = 3;
                itemArray[7] = 6;
                itemArray[8] = 2; //2标识方块为横向长条
                break;
            case 3:
                itemArray[0] = 2;
                itemArray[1] = 3;
                itemArray[2] = 2;
                itemArray[3] = 4;
                itemArray[4] = 3;
                itemArray[5] = 4;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 3; //3标识方块为Z形
                break;
            case 4:
                itemArray[0] = 1;
                itemArray[1] = 5;
                itemArray[2] = 2;
                itemArray[3] = 5;
                itemArray[4] = 2;
                itemArray[5] = 4;
                itemArray[6] = 3;
                itemArray[7] = 4;
                itemArray[8] = 4; //4标识方块为竖直Z形
                break;
            case 5:
                itemArray[0] = 2;
                itemArray[1] = 4;
                itemArray[2] = 2;
                itemArray[3] = 5;
                itemArray[4] = 3;
                itemArray[5] = 3;
                itemArray[6] = 3;
                itemArray[7] = 4;
                itemArray[8] = 5; //5标识方块为反向Z形
                break;
            case 6:
                itemArray[0] = 1;
                itemArray[1] = 4;
                itemArray[2] = 2;
                itemArray[3] = 4;
                itemArray[4] = 2;
                itemArray[5] = 5;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 6; //6标识方块为竖直反向Z形
                break;
            case 7:
                itemArray[0] = 2;
                itemArray[1] = 4;
                itemArray[2] = 3;
                itemArray[3] = 3;
                itemArray[4] = 3;
                itemArray[5] = 4;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 7; //7标识方块为凸形
                break;
            case 8:
                itemArray[0] = 1;
                itemArray[1] = 4;
                itemArray[2] = 2;
                itemArray[3] = 4;
                itemArray[4] = 2;
                itemArray[5] = 5;
                itemArray[6] = 3;
                itemArray[7] = 4;
                itemArray[8] = 8; //8标识方块为右向凸形
                break;
            case 9:
                itemArray[0] = 2;
                itemArray[1] = 3;
                itemArray[2] = 2;
                itemArray[3] = 4;
                itemArray[4] = 2;
                itemArray[5] = 5;
                itemArray[6] = 3;
                itemArray[7] = 4;
                itemArray[8] = 9; //9标识方块为下向凸形
                break;
            case 10:
                itemArray[0] = 1;
                itemArray[1] = 5;
                itemArray[2] = 2;
                itemArray[3] = 4;
                itemArray[4] = 2;
                itemArray[5] = 5;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 10; //10标识方块为左向凸形
                break;
            case 11:
                itemArray[0] = 1;
                itemArray[1] = 4;
                itemArray[2] = 2;
                itemArray[3] = 4;
                itemArray[4] = 3;
                itemArray[5] = 4;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 11; //11标识方块为L形
                break;
            case 12:
                itemArray[0] = 2;
                itemArray[1] = 3;
                itemArray[2] = 2;
                itemArray[3] = 4;
                itemArray[4] = 2;
                itemArray[5] = 5;
                itemArray[6] = 3;
                itemArray[7] = 3;
                itemArray[8] = 12; //12标识方块为下向L形
                break;
            case 13:
                itemArray[0] = 1;
                itemArray[1] = 4;
                itemArray[2] = 1;
                itemArray[3] = 5;
                itemArray[4] = 2;
                itemArray[5] = 5;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 13; //13标识方块为左向L形
                break;
            case 14:
                itemArray[0] = 2;
                itemArray[1] = 5;
                itemArray[2] = 3;
                itemArray[3] = 3;
                itemArray[4] = 3;
                itemArray[5] = 4;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 14; //14标识方块为上向L形
                break;
            case 15:
                itemArray[0] = 1;
                itemArray[1] = 5;
                itemArray[2] = 2;
                itemArray[3] = 5;
                itemArray[4] = 3;
                itemArray[5] = 4;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 15; //15标识方块为翻转L形
                break;
            case 16:
                itemArray[0] = 2;
                itemArray[1] = 3;
                itemArray[2] = 3;
                itemArray[3] = 3;
                itemArray[4] = 3;
                itemArray[5] = 4;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 16; //16标识方块为上向翻转L形
                break;
            case 17:
                itemArray[0] = 1;
                itemArray[1] = 3;
                itemArray[2] = 1;
                itemArray[3] = 4;
                itemArray[4] = 2;
                itemArray[5] = 4;
                itemArray[6] = 3;
                itemArray[7] = 4;
                itemArray[8] = 17; //17标识方块为右向翻转L形
                break;
            default:
                itemArray[0] = 2;
                itemArray[1] = 3;
                itemArray[2] = 2;
                itemArray[3] = 4;
                itemArray[4] = 2;
                itemArray[5] = 5;
                itemArray[6] = 3;
                itemArray[7] = 5;
                itemArray[8] = 18; //18标识方块为下向翻转L形
        }
         System.arraycopy(itemArray,0,Core.movingArray,0,movingArray.length);
    }
    //计分规则
    public static int scoring(int score,int rowNumber){
        int addScore = 0;  //新增的分数
        switch (rowNumber){
            case 0:
                addScore = 0;
                break;
            case 1:
                addScore = 40;
                break;
            case 2:
                addScore = 100;
                break;
            case 3:
                addScore = 300;
                break;
            case 4:
                addScore = 1200;
                break;
        }
        return score + addScore;
    }
    ///数组深复制
    public static int[] arrayCopy(int [] arrayOne){
        int [] arrayTwo = new int[arrayOne.length];
        System.arraycopy(arrayOne,0,arrayTwo,0,arrayTwo.length);
        return arrayTwo;
    }
    //获取指定区间内的随机数
    public static int randomNumber(int min,int max){
        return (int) ((Math.random() * (max + 1 - min)) + min);
    }
}
